use ::libc;
extern "C" {
    fn __assert_fail(
        __assertion: *const libc::c_char,
        __file: *const libc::c_char,
        __line: libc::c_uint,
        __function: *const libc::c_char,
    ) -> !;
    fn strcmp(_: *const libc::c_char, _: *const libc::c_char) -> libc::c_int;
    fn alloc_test_malloc(bytes: size_t) -> *mut libc::c_void;
    fn alloc_test_free(ptr: *mut libc::c_void);
    fn alloc_test_realloc(ptr: *mut libc::c_void, bytes: size_t) -> *mut libc::c_void;
    fn alloc_test_calloc(nmemb: size_t, bytes: size_t) -> *mut libc::c_void;
    fn alloc_test_strdup(string: *const libc::c_char) -> *mut libc::c_char;
    fn alloc_test_set_limit(alloc_count: libc::c_int);
    fn alloc_test_get_allocated() -> size_t;
    fn run_tests(tests_0: *mut UnitTestFunction);
}
pub type size_t = libc::c_ulong;
pub type UnitTestFunction = Option::<unsafe extern "C" fn() -> ()>;
unsafe extern "C" fn test_malloc_free() {
    let mut block: *mut libc::c_void = 0 as *mut libc::c_void;
    let mut block2: *mut libc::c_void = 0 as *mut libc::c_void;
    let mut block3: *mut libc::c_void = 0 as *mut libc::c_void;
    let mut block4: *mut libc::c_void = 0 as *mut libc::c_void;
    let mut ptr: *mut libc::c_uchar = 0 as *mut libc::c_uchar;
    let mut i: libc::c_int = 0;
    if alloc_test_get_allocated() == 0 as libc::c_int as libc::c_ulong {} else {
        __assert_fail(
            b"alloc_test_get_allocated() == 0\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            39 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 28],
                &[libc::c_char; 28],
            >(b"void test_malloc_free(void)\0"))
                .as_ptr(),
        );
    }
    'c_1307: {
        if alloc_test_get_allocated() == 0 as libc::c_int as libc::c_ulong {} else {
            __assert_fail(
                b"alloc_test_get_allocated() == 0\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                39 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 28],
                    &[libc::c_char; 28],
                >(b"void test_malloc_free(void)\0"))
                    .as_ptr(),
            );
        }
    };
    block = alloc_test_malloc(1024 as libc::c_int as size_t);
    if !block.is_null() {} else {
        __assert_fail(
            b"block != NULL\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            43 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 28],
                &[libc::c_char; 28],
            >(b"void test_malloc_free(void)\0"))
                .as_ptr(),
        );
    }
    'c_1260: {
        if !block.is_null() {} else {
            __assert_fail(
                b"block != NULL\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                43 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 28],
                    &[libc::c_char; 28],
                >(b"void test_malloc_free(void)\0"))
                    .as_ptr(),
            );
        }
    };
    if alloc_test_get_allocated() == 1024 as libc::c_int as libc::c_ulong {} else {
        __assert_fail(
            b"alloc_test_get_allocated() == 1024\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            44 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 28],
                &[libc::c_char; 28],
            >(b"void test_malloc_free(void)\0"))
                .as_ptr(),
        );
    }
    'c_1220: {
        if alloc_test_get_allocated() == 1024 as libc::c_int as libc::c_ulong {} else {
            __assert_fail(
                b"alloc_test_get_allocated() == 1024\0" as *const u8
                    as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                44 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 28],
                    &[libc::c_char; 28],
                >(b"void test_malloc_free(void)\0"))
                    .as_ptr(),
            );
        }
    };
    ptr = block as *mut libc::c_uchar;
    i = 0 as libc::c_int;
    while i < 1024 as libc::c_int {
        if *ptr.offset(i as isize) as libc::c_int != 0 as libc::c_int {} else {
            __assert_fail(
                b"ptr[i] != 0\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                51 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 28],
                    &[libc::c_char; 28],
                >(b"void test_malloc_free(void)\0"))
                    .as_ptr(),
            );
        }
        'c_1158: {
            if *ptr.offset(i as isize) as libc::c_int != 0 as libc::c_int {} else {
                __assert_fail(
                    b"ptr[i] != 0\0" as *const u8 as *const libc::c_char,
                    b"../Input/test/test-alloc-testing.c\0" as *const u8
                        as *const libc::c_char,
                    51 as libc::c_int as libc::c_uint,
                    (*::core::mem::transmute::<
                        &[u8; 28],
                        &[libc::c_char; 28],
                    >(b"void test_malloc_free(void)\0"))
                        .as_ptr(),
                );
            }
        };
        i += 1;
        i;
    }
    alloc_test_free(block);
    if alloc_test_get_allocated() == 0 as libc::c_int as libc::c_ulong {} else {
        __assert_fail(
            b"alloc_test_get_allocated() == 0\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            58 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 28],
                &[libc::c_char; 28],
            >(b"void test_malloc_free(void)\0"))
                .as_ptr(),
        );
    }
    'c_1106: {
        if alloc_test_get_allocated() == 0 as libc::c_int as libc::c_ulong {} else {
            __assert_fail(
                b"alloc_test_get_allocated() == 0\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                58 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 28],
                    &[libc::c_char; 28],
                >(b"void test_malloc_free(void)\0"))
                    .as_ptr(),
            );
        }
    };
    alloc_test_set_limit(3 as libc::c_int);
    block = alloc_test_malloc(1024 as libc::c_int as size_t);
    if !block.is_null() {} else {
        __assert_fail(
            b"block != NULL\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            65 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 28],
                &[libc::c_char; 28],
            >(b"void test_malloc_free(void)\0"))
                .as_ptr(),
        );
    }
    'c_1053: {
        if !block.is_null() {} else {
            __assert_fail(
                b"block != NULL\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                65 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 28],
                    &[libc::c_char; 28],
                >(b"void test_malloc_free(void)\0"))
                    .as_ptr(),
            );
        }
    };
    block2 = alloc_test_malloc(1024 as libc::c_int as size_t);
    if !block2.is_null() {} else {
        __assert_fail(
            b"block2 != NULL\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            67 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 28],
                &[libc::c_char; 28],
            >(b"void test_malloc_free(void)\0"))
                .as_ptr(),
        );
    }
    'c_1006: {
        if !block2.is_null() {} else {
            __assert_fail(
                b"block2 != NULL\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                67 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 28],
                    &[libc::c_char; 28],
                >(b"void test_malloc_free(void)\0"))
                    .as_ptr(),
            );
        }
    };
    block3 = alloc_test_malloc(1024 as libc::c_int as size_t);
    if !block3.is_null() {} else {
        __assert_fail(
            b"block3 != NULL\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            69 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 28],
                &[libc::c_char; 28],
            >(b"void test_malloc_free(void)\0"))
                .as_ptr(),
        );
    }
    'c_959: {
        if !block3.is_null() {} else {
            __assert_fail(
                b"block3 != NULL\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                69 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 28],
                    &[libc::c_char; 28],
                >(b"void test_malloc_free(void)\0"))
                    .as_ptr(),
            );
        }
    };
    block4 = alloc_test_malloc(1024 as libc::c_int as size_t);
    if block4.is_null() {} else {
        __assert_fail(
            b"block4 == NULL\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            71 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 28],
                &[libc::c_char; 28],
            >(b"void test_malloc_free(void)\0"))
                .as_ptr(),
        );
    }
    'c_905: {
        if block4.is_null() {} else {
            __assert_fail(
                b"block4 == NULL\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                71 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 28],
                    &[libc::c_char; 28],
                >(b"void test_malloc_free(void)\0"))
                    .as_ptr(),
            );
        }
    };
    alloc_test_free(block);
    alloc_test_free(block2);
    alloc_test_free(block3);
    alloc_test_free(block4);
}
unsafe extern "C" fn test_realloc() {
    let mut block: *mut libc::c_void = 0 as *mut libc::c_void;
    let mut block2: *mut libc::c_void = 0 as *mut libc::c_void;
    block2 = alloc_test_malloc(1024 as libc::c_int as size_t);
    block = alloc_test_malloc(1024 as libc::c_int as size_t);
    if !block.is_null() {} else {
        __assert_fail(
            b"block != NULL\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            91 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 24],
                &[libc::c_char; 24],
            >(b"void test_realloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_2326: {
        if !block.is_null() {} else {
            __assert_fail(
                b"block != NULL\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                91 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 24],
                    &[libc::c_char; 24],
                >(b"void test_realloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    if alloc_test_get_allocated()
        == (1024 as libc::c_int + 1024 as libc::c_int) as libc::c_ulong
    {} else {
        __assert_fail(
            b"alloc_test_get_allocated() == 1024 + 1024\0" as *const u8
                as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            92 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 24],
                &[libc::c_char; 24],
            >(b"void test_realloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_2282: {
        if alloc_test_get_allocated()
            == (1024 as libc::c_int + 1024 as libc::c_int) as libc::c_ulong
        {} else {
            __assert_fail(
                b"alloc_test_get_allocated() == 1024 + 1024\0" as *const u8
                    as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                92 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 24],
                    &[libc::c_char; 24],
                >(b"void test_realloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    block = alloc_test_realloc(block, 2048 as libc::c_int as size_t);
    if !block.is_null() {} else {
        __assert_fail(
            b"block != NULL\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            97 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 24],
                &[libc::c_char; 24],
            >(b"void test_realloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_2233: {
        if !block.is_null() {} else {
            __assert_fail(
                b"block != NULL\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                97 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 24],
                    &[libc::c_char; 24],
                >(b"void test_realloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    if alloc_test_get_allocated()
        == (2048 as libc::c_int + 1024 as libc::c_int) as libc::c_ulong
    {} else {
        __assert_fail(
            b"alloc_test_get_allocated() == 2048 + 1024\0" as *const u8
                as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            99 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 24],
                &[libc::c_char; 24],
            >(b"void test_realloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_2189: {
        if alloc_test_get_allocated()
            == (2048 as libc::c_int + 1024 as libc::c_int) as libc::c_ulong
        {} else {
            __assert_fail(
                b"alloc_test_get_allocated() == 2048 + 1024\0" as *const u8
                    as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                99 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 24],
                    &[libc::c_char; 24],
                >(b"void test_realloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    block = alloc_test_realloc(block, 1500 as libc::c_int as size_t);
    if !block.is_null() {} else {
        __assert_fail(
            b"block != NULL\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            104 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 24],
                &[libc::c_char; 24],
            >(b"void test_realloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_2140: {
        if !block.is_null() {} else {
            __assert_fail(
                b"block != NULL\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                104 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 24],
                    &[libc::c_char; 24],
                >(b"void test_realloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    if alloc_test_get_allocated()
        == (1500 as libc::c_int + 1024 as libc::c_int) as libc::c_ulong
    {} else {
        __assert_fail(
            b"alloc_test_get_allocated() == 1500 + 1024\0" as *const u8
                as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            106 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 24],
                &[libc::c_char; 24],
            >(b"void test_realloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_2096: {
        if alloc_test_get_allocated()
            == (1500 as libc::c_int + 1024 as libc::c_int) as libc::c_ulong
        {} else {
            __assert_fail(
                b"alloc_test_get_allocated() == 1500 + 1024\0" as *const u8
                    as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                106 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 24],
                    &[libc::c_char; 24],
                >(b"void test_realloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    alloc_test_free(block);
    if alloc_test_get_allocated()
        == (0 as libc::c_int + 1024 as libc::c_int) as libc::c_ulong
    {} else {
        __assert_fail(
            b"alloc_test_get_allocated() == 0 + 1024\0" as *const u8
                as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            110 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 24],
                &[libc::c_char; 24],
            >(b"void test_realloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_2046: {
        if alloc_test_get_allocated()
            == (0 as libc::c_int + 1024 as libc::c_int) as libc::c_ulong
        {} else {
            __assert_fail(
                b"alloc_test_get_allocated() == 0 + 1024\0" as *const u8
                    as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                110 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 24],
                    &[libc::c_char; 24],
                >(b"void test_realloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    block = alloc_test_realloc(0 as *mut libc::c_void, 1024 as libc::c_int as size_t);
    if !block.is_null() {} else {
        __assert_fail(
            b"block != NULL\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            116 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 24],
                &[libc::c_char; 24],
            >(b"void test_realloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_1996: {
        if !block.is_null() {} else {
            __assert_fail(
                b"block != NULL\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                116 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 24],
                    &[libc::c_char; 24],
                >(b"void test_realloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    if alloc_test_get_allocated()
        == (1024 as libc::c_int + 1024 as libc::c_int) as libc::c_ulong
    {} else {
        __assert_fail(
            b"alloc_test_get_allocated() == 1024 + 1024\0" as *const u8
                as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            118 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 24],
                &[libc::c_char; 24],
            >(b"void test_realloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_1951: {
        if alloc_test_get_allocated()
            == (1024 as libc::c_int + 1024 as libc::c_int) as libc::c_ulong
        {} else {
            __assert_fail(
                b"alloc_test_get_allocated() == 1024 + 1024\0" as *const u8
                    as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                118 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 24],
                    &[libc::c_char; 24],
                >(b"void test_realloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    alloc_test_free(block);
    alloc_test_free(block2);
    if alloc_test_get_allocated() == 0 as libc::c_int as libc::c_ulong {} else {
        __assert_fail(
            b"alloc_test_get_allocated() == 0\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            123 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 24],
                &[libc::c_char; 24],
            >(b"void test_realloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_1900: {
        if alloc_test_get_allocated() == 0 as libc::c_int as libc::c_ulong {} else {
            __assert_fail(
                b"alloc_test_get_allocated() == 0\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                123 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 24],
                    &[libc::c_char; 24],
                >(b"void test_realloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    block = alloc_test_malloc(512 as libc::c_int as size_t);
    if !block.is_null() {} else {
        __assert_fail(
            b"block != NULL\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            128 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 24],
                &[libc::c_char; 24],
            >(b"void test_realloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_1853: {
        if !block.is_null() {} else {
            __assert_fail(
                b"block != NULL\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                128 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 24],
                    &[libc::c_char; 24],
                >(b"void test_realloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    if alloc_test_get_allocated() == 512 as libc::c_int as libc::c_ulong {} else {
        __assert_fail(
            b"alloc_test_get_allocated() == 512\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            129 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 24],
                &[libc::c_char; 24],
            >(b"void test_realloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_1812: {
        if alloc_test_get_allocated() == 512 as libc::c_int as libc::c_ulong {} else {
            __assert_fail(
                b"alloc_test_get_allocated() == 512\0" as *const u8
                    as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                129 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 24],
                    &[libc::c_char; 24],
                >(b"void test_realloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    alloc_test_set_limit(1 as libc::c_int);
    block = alloc_test_realloc(block, 1024 as libc::c_int as size_t);
    if !block.is_null() {} else {
        __assert_fail(
            b"block != NULL\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            134 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 24],
                &[libc::c_char; 24],
            >(b"void test_realloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_1759: {
        if !block.is_null() {} else {
            __assert_fail(
                b"block != NULL\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                134 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 24],
                    &[libc::c_char; 24],
                >(b"void test_realloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    if alloc_test_get_allocated() == 1024 as libc::c_int as libc::c_ulong {} else {
        __assert_fail(
            b"alloc_test_get_allocated() == 1024\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            135 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 24],
                &[libc::c_char; 24],
            >(b"void test_realloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_1719: {
        if alloc_test_get_allocated() == 1024 as libc::c_int as libc::c_ulong {} else {
            __assert_fail(
                b"alloc_test_get_allocated() == 1024\0" as *const u8
                    as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                135 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 24],
                    &[libc::c_char; 24],
                >(b"void test_realloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    if (alloc_test_realloc(block, 2048 as libc::c_int as size_t)).is_null() {} else {
        __assert_fail(
            b"realloc(block, 2048) == NULL\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            137 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 24],
                &[libc::c_char; 24],
            >(b"void test_realloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_1668: {
        if (alloc_test_realloc(block, 2048 as libc::c_int as size_t)).is_null() {} else {
            __assert_fail(
                b"realloc(block, 2048) == NULL\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                137 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 24],
                    &[libc::c_char; 24],
                >(b"void test_realloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    if alloc_test_get_allocated() == 1024 as libc::c_int as libc::c_ulong {} else {
        __assert_fail(
            b"alloc_test_get_allocated() == 1024\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            138 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 24],
                &[libc::c_char; 24],
            >(b"void test_realloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_1628: {
        if alloc_test_get_allocated() == 1024 as libc::c_int as libc::c_ulong {} else {
            __assert_fail(
                b"alloc_test_get_allocated() == 1024\0" as *const u8
                    as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                138 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 24],
                    &[libc::c_char; 24],
                >(b"void test_realloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    alloc_test_free(block);
    if alloc_test_get_allocated() == 0 as libc::c_int as libc::c_ulong {} else {
        __assert_fail(
            b"alloc_test_get_allocated() == 0\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            141 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 24],
                &[libc::c_char; 24],
            >(b"void test_realloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_1583: {
        if alloc_test_get_allocated() == 0 as libc::c_int as libc::c_ulong {} else {
            __assert_fail(
                b"alloc_test_get_allocated() == 0\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                141 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 24],
                    &[libc::c_char; 24],
                >(b"void test_realloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    alloc_test_set_limit(1 as libc::c_int);
    block = alloc_test_realloc(0 as *mut libc::c_void, 1024 as libc::c_int as size_t);
    if !block.is_null() {} else {
        __assert_fail(
            b"block != NULL\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            148 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 24],
                &[libc::c_char; 24],
            >(b"void test_realloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_1527: {
        if !block.is_null() {} else {
            __assert_fail(
                b"block != NULL\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                148 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 24],
                    &[libc::c_char; 24],
                >(b"void test_realloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    if alloc_test_get_allocated() == 1024 as libc::c_int as libc::c_ulong {} else {
        __assert_fail(
            b"alloc_test_get_allocated() == 1024\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            149 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 24],
                &[libc::c_char; 24],
            >(b"void test_realloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_1487: {
        if alloc_test_get_allocated() == 1024 as libc::c_int as libc::c_ulong {} else {
            __assert_fail(
                b"alloc_test_get_allocated() == 1024\0" as *const u8
                    as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                149 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 24],
                    &[libc::c_char; 24],
                >(b"void test_realloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    if (alloc_test_realloc(0 as *mut libc::c_void, 1024 as libc::c_int as size_t))
        .is_null()
    {} else {
        __assert_fail(
            b"realloc(NULL, 1024) == NULL\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            151 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 24],
                &[libc::c_char; 24],
            >(b"void test_realloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_1434: {
        if (alloc_test_realloc(0 as *mut libc::c_void, 1024 as libc::c_int as size_t))
            .is_null()
        {} else {
            __assert_fail(
                b"realloc(NULL, 1024) == NULL\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                151 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 24],
                    &[libc::c_char; 24],
                >(b"void test_realloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    if alloc_test_get_allocated() == 1024 as libc::c_int as libc::c_ulong {} else {
        __assert_fail(
            b"alloc_test_get_allocated() == 1024\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            152 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 24],
                &[libc::c_char; 24],
            >(b"void test_realloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_1393: {
        if alloc_test_get_allocated() == 1024 as libc::c_int as libc::c_ulong {} else {
            __assert_fail(
                b"alloc_test_get_allocated() == 1024\0" as *const u8
                    as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                152 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 24],
                    &[libc::c_char; 24],
                >(b"void test_realloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    alloc_test_free(block);
}
unsafe extern "C" fn test_calloc() {
    let mut block: *mut libc::c_uchar = 0 as *mut libc::c_uchar;
    let mut i: libc::c_int = 0;
    if alloc_test_get_allocated() == 0 as libc::c_int as libc::c_ulong {} else {
        __assert_fail(
            b"alloc_test_get_allocated() == 0\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            162 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 23],
                &[libc::c_char; 23],
            >(b"void test_calloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_2791: {
        if alloc_test_get_allocated() == 0 as libc::c_int as libc::c_ulong {} else {
            __assert_fail(
                b"alloc_test_get_allocated() == 0\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                162 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 23],
                    &[libc::c_char; 23],
                >(b"void test_calloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    block = alloc_test_calloc(16 as libc::c_int as size_t, 64 as libc::c_int as size_t)
        as *mut libc::c_uchar;
    if alloc_test_get_allocated() == 1024 as libc::c_int as libc::c_ulong {} else {
        __assert_fail(
            b"alloc_test_get_allocated() == 1024\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            168 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 23],
                &[libc::c_char; 23],
            >(b"void test_calloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_2741: {
        if alloc_test_get_allocated() == 1024 as libc::c_int as libc::c_ulong {} else {
            __assert_fail(
                b"alloc_test_get_allocated() == 1024\0" as *const u8
                    as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                168 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 23],
                    &[libc::c_char; 23],
                >(b"void test_calloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    if !block.is_null() {} else {
        __assert_fail(
            b"block != NULL\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            170 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 23],
                &[libc::c_char; 23],
            >(b"void test_calloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_2699: {
        if !block.is_null() {} else {
            __assert_fail(
                b"block != NULL\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                170 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 23],
                    &[libc::c_char; 23],
                >(b"void test_calloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    i = 0 as libc::c_int;
    while i < 1024 as libc::c_int {
        if *block.offset(i as isize) as libc::c_int == 0 as libc::c_int {} else {
            __assert_fail(
                b"block[i] == 0\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                175 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 23],
                    &[libc::c_char; 23],
                >(b"void test_calloc(void)\0"))
                    .as_ptr(),
            );
        }
        'c_2645: {
            if *block.offset(i as isize) as libc::c_int == 0 as libc::c_int {} else {
                __assert_fail(
                    b"block[i] == 0\0" as *const u8 as *const libc::c_char,
                    b"../Input/test/test-alloc-testing.c\0" as *const u8
                        as *const libc::c_char,
                    175 as libc::c_int as libc::c_uint,
                    (*::core::mem::transmute::<
                        &[u8; 23],
                        &[libc::c_char; 23],
                    >(b"void test_calloc(void)\0"))
                        .as_ptr(),
                );
            }
        };
        i += 1;
        i;
    }
    alloc_test_free(block as *mut libc::c_void);
    if alloc_test_get_allocated() == 0 as libc::c_int as libc::c_ulong {} else {
        __assert_fail(
            b"alloc_test_get_allocated() == 0\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            180 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 23],
                &[libc::c_char; 23],
            >(b"void test_calloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_2594: {
        if alloc_test_get_allocated() == 0 as libc::c_int as libc::c_ulong {} else {
            __assert_fail(
                b"alloc_test_get_allocated() == 0\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                180 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 23],
                    &[libc::c_char; 23],
                >(b"void test_calloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    alloc_test_set_limit(1 as libc::c_int);
    block = alloc_test_calloc(1024 as libc::c_int as size_t, 1 as libc::c_int as size_t)
        as *mut libc::c_uchar;
    if !block.is_null() {} else {
        __assert_fail(
            b"block != NULL\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            187 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 23],
                &[libc::c_char; 23],
            >(b"void test_calloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_2537: {
        if !block.is_null() {} else {
            __assert_fail(
                b"block != NULL\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                187 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 23],
                    &[libc::c_char; 23],
                >(b"void test_calloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    if alloc_test_get_allocated() == 1024 as libc::c_int as libc::c_ulong {} else {
        __assert_fail(
            b"alloc_test_get_allocated() == 1024\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            188 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 23],
                &[libc::c_char; 23],
            >(b"void test_calloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_2497: {
        if alloc_test_get_allocated() == 1024 as libc::c_int as libc::c_ulong {} else {
            __assert_fail(
                b"alloc_test_get_allocated() == 1024\0" as *const u8
                    as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                188 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 23],
                    &[libc::c_char; 23],
                >(b"void test_calloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    if (alloc_test_calloc(1024 as libc::c_int as size_t, 1 as libc::c_int as size_t))
        .is_null()
    {} else {
        __assert_fail(
            b"calloc(1024, 1) == NULL\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            190 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 23],
                &[libc::c_char; 23],
            >(b"void test_calloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_2446: {
        if (alloc_test_calloc(1024 as libc::c_int as size_t, 1 as libc::c_int as size_t))
            .is_null()
        {} else {
            __assert_fail(
                b"calloc(1024, 1) == NULL\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                190 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 23],
                    &[libc::c_char; 23],
                >(b"void test_calloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    if alloc_test_get_allocated() == 1024 as libc::c_int as libc::c_ulong {} else {
        __assert_fail(
            b"alloc_test_get_allocated() == 1024\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            191 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 23],
                &[libc::c_char; 23],
            >(b"void test_calloc(void)\0"))
                .as_ptr(),
        );
    }
    'c_2405: {
        if alloc_test_get_allocated() == 1024 as libc::c_int as libc::c_ulong {} else {
            __assert_fail(
                b"alloc_test_get_allocated() == 1024\0" as *const u8
                    as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                191 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 23],
                    &[libc::c_char; 23],
                >(b"void test_calloc(void)\0"))
                    .as_ptr(),
            );
        }
    };
    alloc_test_free(block as *mut libc::c_void);
}
unsafe extern "C" fn test_strdup() {
    let mut str: *mut libc::c_char = 0 as *mut libc::c_char;
    if alloc_test_get_allocated() == 0 as libc::c_int as libc::c_ulong {} else {
        __assert_fail(
            b"alloc_test_get_allocated() == 0\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            200 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 23],
                &[libc::c_char; 23],
            >(b"void test_strdup(void)\0"))
                .as_ptr(),
        );
    }
    'c_3224: {
        if alloc_test_get_allocated() == 0 as libc::c_int as libc::c_ulong {} else {
            __assert_fail(
                b"alloc_test_get_allocated() == 0\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                200 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 23],
                    &[libc::c_char; 23],
                >(b"void test_strdup(void)\0"))
                    .as_ptr(),
            );
        }
    };
    str = alloc_test_strdup(b"hello world\0" as *const u8 as *const libc::c_char);
    if !str.is_null() {} else {
        __assert_fail(
            b"str != NULL\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            206 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 23],
                &[libc::c_char; 23],
            >(b"void test_strdup(void)\0"))
                .as_ptr(),
        );
    }
    'c_3175: {
        if !str.is_null() {} else {
            __assert_fail(
                b"str != NULL\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                206 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 23],
                    &[libc::c_char; 23],
                >(b"void test_strdup(void)\0"))
                    .as_ptr(),
            );
        }
    };
    if strcmp(str, b"hello world\0" as *const u8 as *const libc::c_char)
        == 0 as libc::c_int
    {} else {
        __assert_fail(
            b"strcmp(str, \"hello world\") == 0\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            207 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 23],
                &[libc::c_char; 23],
            >(b"void test_strdup(void)\0"))
                .as_ptr(),
        );
    }
    'c_3126: {
        if strcmp(str, b"hello world\0" as *const u8 as *const libc::c_char)
            == 0 as libc::c_int
        {} else {
            __assert_fail(
                b"strcmp(str, \"hello world\") == 0\0" as *const u8
                    as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                207 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 23],
                    &[libc::c_char; 23],
                >(b"void test_strdup(void)\0"))
                    .as_ptr(),
            );
        }
    };
    if alloc_test_get_allocated() == 12 as libc::c_int as libc::c_ulong {} else {
        __assert_fail(
            b"alloc_test_get_allocated() == 12\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            209 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 23],
                &[libc::c_char; 23],
            >(b"void test_strdup(void)\0"))
                .as_ptr(),
        );
    }
    'c_3086: {
        if alloc_test_get_allocated() == 12 as libc::c_int as libc::c_ulong {} else {
            __assert_fail(
                b"alloc_test_get_allocated() == 12\0" as *const u8
                    as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                209 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 23],
                    &[libc::c_char; 23],
                >(b"void test_strdup(void)\0"))
                    .as_ptr(),
            );
        }
    };
    alloc_test_free(str as *mut libc::c_void);
    if alloc_test_get_allocated() == 0 as libc::c_int as libc::c_ulong {} else {
        __assert_fail(
            b"alloc_test_get_allocated() == 0\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            213 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 23],
                &[libc::c_char; 23],
            >(b"void test_strdup(void)\0"))
                .as_ptr(),
        );
    }
    'c_3040: {
        if alloc_test_get_allocated() == 0 as libc::c_int as libc::c_ulong {} else {
            __assert_fail(
                b"alloc_test_get_allocated() == 0\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                213 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 23],
                    &[libc::c_char; 23],
                >(b"void test_strdup(void)\0"))
                    .as_ptr(),
            );
        }
    };
    alloc_test_set_limit(1 as libc::c_int);
    str = alloc_test_strdup(b"hello world\0" as *const u8 as *const libc::c_char);
    if !str.is_null() {} else {
        __assert_fail(
            b"str != NULL\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            220 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 23],
                &[libc::c_char; 23],
            >(b"void test_strdup(void)\0"))
                .as_ptr(),
        );
    }
    'c_2986: {
        if !str.is_null() {} else {
            __assert_fail(
                b"str != NULL\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                220 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 23],
                    &[libc::c_char; 23],
                >(b"void test_strdup(void)\0"))
                    .as_ptr(),
            );
        }
    };
    if alloc_test_get_allocated() == 12 as libc::c_int as libc::c_ulong {} else {
        __assert_fail(
            b"alloc_test_get_allocated() == 12\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            221 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 23],
                &[libc::c_char; 23],
            >(b"void test_strdup(void)\0"))
                .as_ptr(),
        );
    }
    'c_2946: {
        if alloc_test_get_allocated() == 12 as libc::c_int as libc::c_ulong {} else {
            __assert_fail(
                b"alloc_test_get_allocated() == 12\0" as *const u8
                    as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                221 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 23],
                    &[libc::c_char; 23],
                >(b"void test_strdup(void)\0"))
                    .as_ptr(),
            );
        }
    };
    if (alloc_test_strdup(b"hello world\0" as *const u8 as *const libc::c_char))
        .is_null()
    {} else {
        __assert_fail(
            b"strdup(\"hello world\") == NULL\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            223 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 23],
                &[libc::c_char; 23],
            >(b"void test_strdup(void)\0"))
                .as_ptr(),
        );
    }
    'c_2896: {
        if (alloc_test_strdup(b"hello world\0" as *const u8 as *const libc::c_char))
            .is_null()
        {} else {
            __assert_fail(
                b"strdup(\"hello world\") == NULL\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                223 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 23],
                    &[libc::c_char; 23],
                >(b"void test_strdup(void)\0"))
                    .as_ptr(),
            );
        }
    };
    if alloc_test_get_allocated() == 12 as libc::c_int as libc::c_ulong {} else {
        __assert_fail(
            b"alloc_test_get_allocated() == 12\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            224 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 23],
                &[libc::c_char; 23],
            >(b"void test_strdup(void)\0"))
                .as_ptr(),
        );
    }
    'c_2855: {
        if alloc_test_get_allocated() == 12 as libc::c_int as libc::c_ulong {} else {
            __assert_fail(
                b"alloc_test_get_allocated() == 12\0" as *const u8
                    as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                224 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 23],
                    &[libc::c_char; 23],
                >(b"void test_strdup(void)\0"))
                    .as_ptr(),
            );
        }
    };
    alloc_test_free(str as *mut libc::c_void);
}
unsafe extern "C" fn test_limits() {
    let mut block: *mut libc::c_void = 0 as *mut libc::c_void;
    block = alloc_test_malloc(2048 as libc::c_int as size_t);
    if !block.is_null() {} else {
        __assert_fail(
            b"block != NULL\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            236 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 23],
                &[libc::c_char; 23],
            >(b"void test_limits(void)\0"))
                .as_ptr(),
        );
    }
    'c_3445: {
        if !block.is_null() {} else {
            __assert_fail(
                b"block != NULL\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                236 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 23],
                    &[libc::c_char; 23],
                >(b"void test_limits(void)\0"))
                    .as_ptr(),
            );
        }
    };
    alloc_test_free(block);
    alloc_test_set_limit(1 as libc::c_int);
    block = alloc_test_malloc(1024 as libc::c_int as size_t);
    if !block.is_null() {} else {
        __assert_fail(
            b"block != NULL\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            243 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 23],
                &[libc::c_char; 23],
            >(b"void test_limits(void)\0"))
                .as_ptr(),
        );
    }
    'c_3389: {
        if !block.is_null() {} else {
            __assert_fail(
                b"block != NULL\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                243 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 23],
                    &[libc::c_char; 23],
                >(b"void test_limits(void)\0"))
                    .as_ptr(),
            );
        }
    };
    if (alloc_test_malloc(1024 as libc::c_int as size_t)).is_null() {} else {
        __assert_fail(
            b"malloc(1024) == NULL\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            244 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 23],
                &[libc::c_char; 23],
            >(b"void test_limits(void)\0"))
                .as_ptr(),
        );
    }
    'c_3342: {
        if (alloc_test_malloc(1024 as libc::c_int as size_t)).is_null() {} else {
            __assert_fail(
                b"malloc(1024) == NULL\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                244 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 23],
                    &[libc::c_char; 23],
                >(b"void test_limits(void)\0"))
                    .as_ptr(),
            );
        }
    };
    alloc_test_free(block);
    alloc_test_set_limit(-(1 as libc::c_int));
    block = alloc_test_malloc(1024 as libc::c_int as size_t);
    if !block.is_null() {} else {
        __assert_fail(
            b"block != NULL\0" as *const u8 as *const libc::c_char,
            b"../Input/test/test-alloc-testing.c\0" as *const u8 as *const libc::c_char,
            251 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 23],
                &[libc::c_char; 23],
            >(b"void test_limits(void)\0"))
                .as_ptr(),
        );
    }
    'c_3285: {
        if !block.is_null() {} else {
            __assert_fail(
                b"block != NULL\0" as *const u8 as *const libc::c_char,
                b"../Input/test/test-alloc-testing.c\0" as *const u8
                    as *const libc::c_char,
                251 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 23],
                    &[libc::c_char; 23],
                >(b"void test_limits(void)\0"))
                    .as_ptr(),
            );
        }
    };
    alloc_test_free(block);
}
static mut tests: [UnitTestFunction; 6] = unsafe {
    [
        Some(test_malloc_free as unsafe extern "C" fn() -> ()),
        Some(test_realloc as unsafe extern "C" fn() -> ()),
        Some(test_calloc as unsafe extern "C" fn() -> ()),
        Some(test_strdup as unsafe extern "C" fn() -> ()),
        Some(test_limits as unsafe extern "C" fn() -> ()),
        None,
    ]
};
unsafe fn main_0(
    mut argc: libc::c_int,
    mut argv: *mut *mut libc::c_char,
) -> libc::c_int {
    run_tests(tests.as_mut_ptr());
    return 0 as libc::c_int;
}
pub fn main() {
    let mut args: Vec::<*mut libc::c_char> = Vec::new();
    for arg in ::std::env::args() {
        args.push(
            (::std::ffi::CString::new(arg))
                .expect("Failed to convert argument into CString.")
                .into_raw(),
        );
    }
    args.push(::core::ptr::null_mut());
    unsafe {
        ::std::process::exit(
            main_0(
                (args.len() - 1) as libc::c_int,
                args.as_mut_ptr() as *mut *mut libc::c_char,
            ) as i32,
        )
    }
}
